home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 43 / Mac Magazin and MacEasy Magazine CD - Issue 43.iso / Software / Multimedia / Sound / PlayerPRO 4.6 Dev.Kit / MADH Library 4.6 / MADLibrary Source / Interrupt.c < prev    next >
Encoding:
Text File  |  1998-01-23  |  30.5 KB  |  1,264 lines  |  [TEXT/CWIE]
  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 4.6 - DRIVER SOURCE CODE -
  4. //
  5. //    Library Version 4.6
  6. //
  7. //    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
  15. //
  16. //    Thank you for your interest in PlayerPRO !
  17. //
  18. //    FAX:            (+41 22) 346 11 97
  19. //    PHONE:             (+41 79) 203 74 62
  20. //    Internet:         rosset@dial.eunet.ch or RossetAntoine@bluewin.ch
  21. //
  22. /********************                        ***********************/
  23.  
  24. #include "RDriver.h"
  25. #include "RDriverInt.h"
  26. #include "AWACDriver.h"
  27.  
  28. #ifdef _MAC_H
  29. #include "OMS.h"
  30. #endif
  31.  
  32. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver);
  33. void ApplyFilters( MADDriverRec *intDriver);
  34. void ApplySurround( MADDriverRec *intDriver);
  35.  
  36. /*void Interpolation()
  37. {
  38.     long    variable = 0, i, frequence = 0, IndexTable = 0, ValeurTable = 0, Table1 = 0, Table2 = 0;
  39.     long    TableOnde[ 256];
  40.     
  41.     frequence = 128;
  42.     
  43.     for( i = 0; i < 256; i++)
  44.     {
  45.         variable = variable + frequence;
  46.         if( variable > 1) variable--;
  47.         
  48.         ValeurTable = variable*256;
  49.         
  50.         Table1 = TableOnde[ ValeurTable];
  51.         ValeurTable = IndexTable+1;
  52.         
  53.         
  54.         //
  55.         if( ValeurTable == 256) ValeurTable = 0;
  56.         
  57.         Table2 = TableOnde[ ValeurTable];
  58.         Table1 = Table1 + (Table2 - Table1) * (256*variable - ((long) 256*variable));
  59.         //
  60.     }
  61. }*/
  62.  
  63.  
  64. long DoVol( Channel *ch)    // MAX = 64
  65. {
  66.     return ((long)ch->vol * (long)ch->volEnv * (long)ch->volFade) / (64L*32767L);
  67. }
  68.  
  69. void MADCleanDriver( MADDriverRec *intDriver)
  70. {
  71.     short        i, x;
  72.  
  73.     for( i = 0; i < MAXTRACK; i++)
  74.     {
  75.         intDriver->chan[i].ID        = i;
  76.         
  77.         intDriver->chan[i].begPtr     = 0L;
  78.         intDriver->chan[i].maxPtr     = 0L;
  79.         intDriver->chan[i].curPtr     = 0L;
  80.         intDriver->chan[i].sizePtr     = 0L;
  81.         
  82.         intDriver->chan[i].amp        = 8;
  83.  
  84.         intDriver->chan[i].loopBeg     = 0;
  85.         intDriver->chan[i].loopSize    = 0;
  86.         
  87.         intDriver->chan[i].ins         = 0;
  88.         intDriver->chan[i].insOld     = 0;
  89.  
  90.         intDriver->chan[i].fineTune = NOFINETUNE;
  91.  
  92.         intDriver->chan[i].note        = 0xFF;
  93.         intDriver->chan[i].noteOld    = 0xFF;
  94.  
  95.         
  96.         intDriver->chan[i].period    = GetOldPeriod( 40, NOFINETUNE, intDriver);
  97.         intDriver->chan[i].periodOld= GetOldPeriod( 40, NOFINETUNE, intDriver);
  98.         
  99.         intDriver->chan[i].vol        = 64;
  100.         intDriver->chan[i].cmd        = 0;
  101.         intDriver->chan[i].arg        = 0;
  102.         
  103.         for( x = 0; x < MAX_ARP; x++) intDriver->chan[i].arp[ x] = 0;
  104.         intDriver->chan[i].arpindex = 0;
  105.         
  106.         intDriver->chan[i].viboffset    = 0;
  107.         intDriver->chan[i].vibdepth     = 0;
  108.         intDriver->chan[i].vibrate         = 0;
  109.         intDriver->chan[i].slide         = 0;
  110.         intDriver->chan[i].pitchgoal     = 0;
  111.         intDriver->chan[i].pitchrate     = 0;
  112.         intDriver->chan[i].volumerate     = 0;
  113.         intDriver->chan[i].samplePtr     = 0L;
  114.         intDriver->chan[i].volcmd        = 0L;
  115.         
  116.         for( x = 0; x < 16; x++) intDriver->chan[ i].oldArg[ x] = 0;
  117.         
  118.         intDriver->chan[i].KeyOn        = false;
  119.         intDriver->chan[i].a            = 0;
  120.         intDriver->chan[i].b            = 1;
  121.         intDriver->chan[i].p            = 0;
  122.         intDriver->chan[i].volEnv        = 64;
  123.         intDriver->chan[i].volFade        = 32767;
  124.         intDriver->chan[i].lAC            = 0;
  125.         
  126.         intDriver->chan[i].lastWord        = 0;
  127.         intDriver->chan[i].curLevel        = 0;
  128.         intDriver->chan[i].prevPtr        = 0;
  129.         intDriver->chan[i].prevVol        = 0;
  130.         intDriver->chan[i].curPrevVol    = 0;
  131.     }
  132.     
  133.     intDriver->BufCounter = 0;    intDriver->BytesToGenerate = 0;
  134.     
  135.     for( i = 0; i < MAXTRACK; i++) intDriver->TrackLineReading[ i] = true;
  136. }
  137.  
  138. long Interpolate(long p,long p1,long p2,long v1,long v2)
  139. {
  140.     long dp,dv,di;
  141.  
  142.     if( p1 == p2) return v1;
  143.  
  144.     dv=v2-v1;
  145.     dp=p2-p1;
  146.     di=p-p1;
  147.  
  148.     return v1 + ((long)(di*dv) / dp);
  149. }
  150.  
  151. long InterpolateEnv(long p, EnvRec *a,EnvRec *b)
  152. {
  153.     if( p < a->pos) return a->val;
  154.     return(Interpolate(p,a->pos,b->pos,a->val,b->val));
  155. }
  156.  
  157. void ProcessFadeOut( Channel *ch, MADDriverRec *intDriver)
  158. {
  159.     if( !ch->KeyOn)
  160.     {
  161.         ch->volFade -= intDriver->curMusic->header->fid[ ch->ins].volFade;
  162.         if( ch->volFade < 0)
  163.         {
  164.             ch->volFade     = 0;
  165.             ch->loopBeg     = 0;
  166.             ch->loopSize     = 0;
  167.         }
  168.     }
  169. }
  170.  
  171. void ProcessEnvelope( Channel *ch, MADDriverRec *intDriver)
  172. {
  173.     long        v;
  174.     InstrData    *curIns;
  175.     
  176.     ch->volEnv = 64;
  177.     if( ch->ins < 0) return;
  178.     if( ch->samplePtr != 0L) return;
  179.     curIns = &intDriver->curMusic->header->fid[ ch->ins];
  180.     if( curIns->volSize <= 0) return;
  181.     
  182.     if( curIns->volType & EFON)
  183.     {
  184.         //  active? -> copy variables
  185.         
  186.         Byte     a,b;
  187.         short    p;
  188.         
  189.         a=ch->a;
  190.         b=ch->b;
  191.         p=ch->p;
  192.         
  193.         v = InterpolateEnv( p, &curIns->volEnv[a], &curIns->volEnv[b]);
  194.  
  195.         if((curIns->volType & EFSUSTAIN) && ch->KeyOn && a==curIns->volSus && p==curIns->volEnv[a].pos){
  196.         }
  197.         else{
  198.             p++;
  199.             
  200.             if(p >= curIns->volEnv[b].pos)
  201.             {
  202.                 a=b; b++;
  203.                 
  204.                 if(curIns->volType & EFLOOP)
  205.                 {
  206.                     if(b > curIns->volEnd)
  207.                     {
  208.                         a=curIns->volBeg;
  209.                         b=a+1;
  210.                         p=curIns->volEnv[a].pos;
  211.                     }
  212.                 }
  213.                 else
  214.                 {
  215.                     if(b >= curIns->volSize)
  216.                     {
  217.                         b--;
  218.                         p--;
  219.                     }
  220.                 }
  221.             }
  222.         }
  223.         ch->a=a;
  224.         ch->b=b;
  225.         ch->p=p;
  226.         
  227.         ch->volEnv = v;
  228.     }
  229. }
  230.  
  231. void StartEnvelope( Channel *ch)
  232. {
  233.     ch->p=0;
  234.     ch->a=0;
  235.     ch->b=1;
  236. }
  237.  
  238. long GetOldPeriod( short note, long c2spd, MADDriverRec *intDriver)
  239. {
  240.     unsigned long     period, n,o;
  241.     
  242.     if( note == 0xFF) return 4242;
  243.     if( note == 0xFE) return 4242;
  244.     
  245. //    if(!c2spd) DebugStr("\pNo c2spd");
  246.     if(!c2spd) return 4242;
  247.  
  248.     n = note%12;
  249.     o = note/12;
  250.     
  251.     period = (unsigned long) ((unsigned long) ( 8363UL * ((unsigned long) intDriver->lib->mytab[ n]) ) >> o ) / (unsigned long) c2spd;
  252.     
  253.     if( period == 0L) period = 7242;
  254.     
  255.     return period;
  256.  
  257. //    return( getlogperiod( note, c2spd));
  258.  
  259. //    period = GetFreq2( getlinearperiod( note, c2spd)) * AMIGA_CLOCKFREQ2;
  260. //    return( period);
  261. }
  262.  
  263. void ReadNote( Channel *curVoice, Cmd *theNoteCmd, MADDriverRec *intDriver)
  264. {
  265. Cmd            intCmd = *theNoteCmd;
  266.  
  267. /********************************************/
  268. /*        EXTRA small positionning          */
  269. /********************************************/
  270.  
  271. if( intCmd.cmd == 0x0E && (intCmd.arg >> 4) == 0x0D)
  272. {
  273.     if( intDriver->smallcounter == 0 && !curVoice->GEffect)
  274.     {
  275.         curVoice->GEffect     = true;
  276.         curVoice->GPat         = intDriver->Pat;
  277.         curVoice->GReader     = intDriver->PartitionReader;
  278.     }
  279.     
  280.     if( intDriver->smallcounter >= (intCmd.arg & 0x0F))
  281.     {
  282.         curVoice->GEffect = false;        // <- Continue - Play note NOW !
  283.     }
  284.     else return;                        // <- Do it later
  285. }
  286. else curVoice->GEffect = false;            // <- Continue
  287.  
  288. /********************************************/
  289. /* Play a sample sound in priority to music */
  290. /********************************************/
  291. if( curVoice->samplePtr != 0L) return;
  292.  
  293. /********************************************/
  294.  
  295. /********************************************/
  296. /*        Read command and compute it       */
  297. /********************************************/
  298. else if( intCmd.ins != 0 || (intCmd.note != 0xFF && intCmd.note != 0xFE))
  299. {
  300.     /********************************/
  301.     /* Prépare les notes manquantes */
  302.     /********************************/
  303.  
  304.     if( intCmd.ins == 0)         { intCmd.ins                = curVoice->insOld;}
  305.     else                                         { curVoice->insOld         = intCmd.ins; }
  306.     
  307. //    if( intCmd.note == 0xFF)    intCmd.note            = curVoice->noteOld;
  308. //    else                         curVoice->noteOld         = intCmd.note;
  309.     
  310.     /********************************/
  311.     
  312.     if( intCmd.ins != 0 && (intCmd.note != 0xFF && intCmd.note != 0xFE))
  313.     {
  314.         sData    *curData;
  315.         short    ins, samp;
  316.         
  317.         /**** INSTRUMENT ****/
  318.         
  319.         ins                        = intCmd.ins - 1;        if( ins >= MAXINSTRU) ins = MAXINSTRU-1;
  320.         samp                    = intDriver->curMusic->header->fid[ ins].what[ intCmd.note];
  321.         
  322.         if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  323.         {
  324.             curVoice->ins            = ins;
  325.         }
  326.         
  327.         if( samp < intDriver->curMusic->header->fid[ ins].numSamples)
  328.         {
  329.             curData                    = intDriver->curMusic->sample[ ins][ samp];
  330.             curVoice->ins            = ins;
  331.             curVoice->amp            = curData->amp;
  332.             curVoice->samp            = samp;
  333.             
  334.             /**** RESET NOTE ****/
  335.             if( intCmd.cmd != portamentoE && intCmd.cmd != portaslideE)
  336.             {
  337.                 curVoice->prevPtr        = 0L;
  338.                 curVoice->maxPtr         = curVoice->curPtr = curVoice->begPtr = curData->data;
  339.                 curVoice->maxPtr         += curData->size;
  340.                 curVoice->sizePtr        = curData->size;
  341.                 curVoice->lAC            = 0;
  342.                 
  343.                 if( curData->loopSize > 2)
  344.                 {
  345.                     curVoice->loopBeg     = curData->loopBeg;
  346.                     curVoice->loopSize    = curData->loopSize;
  347.                     curVoice->maxPtr     = (Ptr) ((long) curData->data + curData->loopBeg + curData->loopSize);
  348.                 }
  349.                 else
  350.                 {
  351.                     curVoice->loopBeg     = 0;
  352.                     curVoice->loopSize    = 0;
  353.                 }
  354.                 curVoice->viboffset        = 0;
  355.                 
  356.             if(intCmd.cmd != volumeE)
  357.             {
  358.                     curVoice->vol             = curData->vol;
  359.                     if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  360.                 }
  361.                 curVoice->volFade        = 32767;
  362.                 
  363.                 StartEnvelope( curVoice);
  364.             }
  365.             
  366.             intDriver->InstruTube[ ins]         = 64;
  367.             intDriver->InstruActif[ ins]         = curVoice->ID;
  368.         }
  369.     }
  370.     else if( intCmd.ins != 0 && intCmd.note == 0xFF)
  371.     {
  372.         if( curVoice->samp < intDriver->curMusic->header->fid[ curVoice->ins].numSamples)
  373.         {
  374.             sData    *curData;
  375.             
  376.             curData                    = intDriver->curMusic->sample[ curVoice->ins][ curVoice->samp];
  377.             
  378.             if( curData != 0L)
  379.             {
  380.                 if( intCmd.cmd != slidevolE && intCmd.cmd != volumeE)
  381.                 {
  382.                 curVoice->vol             = curData->vol;
  383.                 if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  384.                 
  385.                 curVoice->volFade        = 32767;
  386.                 }
  387.             }
  388.         }
  389.     }
  390.     
  391.     if( intCmd.note != 0xFF && intCmd.note != 0xFE)
  392.     {
  393.         /**** NOTE & PERIOD ****/
  394.         
  395.         sData    *curData;
  396.         short    samp;
  397.  
  398.         samp                    = intDriver->curMusic->header->fid[ curVoice->ins].what[ intCmd.note];
  399.         if( samp < intDriver->curMusic->header->fid[ curVoice->ins].numSamples)
  400.         {
  401.             curData                    = intDriver->curMusic->sample[ curVoice->ins][ samp];
  402.             
  403.             curVoice->note            = intCmd.note + curData->relNote;
  404.             curVoice->fineTune        = curData->c2spd;
  405.             curVoice->KeyOn            = true;
  406.             
  407.             if( intCmd.cmd != portamentoE && intCmd.cmd != portaslideE)
  408.             {
  409.                 curVoice->period         = GetOldPeriod( curVoice->note, curVoice->fineTune, intDriver);
  410.                 curVoice->periodOld     = curVoice->period = (curVoice->period * (long) intDriver->FreqExt) / 80L;
  411.             }
  412.         }
  413.         
  414.         /***********************/
  415.         /* Pour le MIDI Driver */
  416.         /***********************/
  417.         if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  418.         {
  419.             if( intDriver->NoteOld[ curVoice->ID] != -1)
  420.             {
  421.                 NoteOff( intDriver->InstuNoOld[ curVoice->ID], intDriver->NoteOld[ curVoice->ID], intDriver->VelocityOld[ curVoice->ID], intDriver);
  422.                 intDriver->NoteOld[ curVoice->ID] = -1;
  423.             }
  424.             
  425.             SampleMIDI( curVoice, curVoice->ins, intCmd.note, intDriver);
  426.             
  427.             intDriver->InstuNoOld[ curVoice->ID]    = curVoice->ins;
  428.             intDriver->NoteOld[ curVoice->ID]        = intCmd.note;
  429.             intDriver->VelocityOld[ curVoice->ID]    = curVoice->vol;
  430.         }
  431.         /***********************/
  432.     }
  433. }
  434. else
  435. {
  436.     curVoice->note = 0xFF;
  437. }
  438.  
  439. /**************/
  440. /*   VOLUME   */
  441. /**************/
  442. if( intCmd.vol != 0xFF)
  443. {
  444.     if(intCmd.vol >= 0x10 && intCmd.vol <= 0x50)
  445.     {
  446.         curVoice->vol = intCmd.vol - 0x10;
  447.         if( curVoice->vol < MIN_VOLUME) curVoice->vol = MIN_VOLUME;
  448.         else if( curVoice->vol > MAX_VOLUME) curVoice->vol = MAX_VOLUME;
  449.  
  450.         curVoice->volcmd = 0;
  451.     }
  452.     else curVoice->volcmd = intCmd.vol;
  453. }
  454. else curVoice->volcmd = 0;
  455.  
  456. curVoice->cmd        = intCmd.cmd;
  457. curVoice->arg         = intCmd.arg;
  458.  
  459. SetUpEffect( curVoice, intDriver);
  460.  
  461. if( intCmd.ins != 0 && intCmd.note != 0xFF) intDriver->Tube[ curVoice->ID] = curVoice->vol;
  462.  
  463.  
  464. /**************/
  465. /*   KEY OFF  */
  466. /**************/
  467. if( intCmd.note == 0xFE)
  468. {
  469.     curVoice->KeyOn    = false;
  470.     
  471.     if( intDriver->DriverSettings.driverMode == MIDISoundDriver)
  472.     {
  473.         if( intDriver->NoteOld[ curVoice->ID] != -1)
  474.             NoteOff( intDriver->InstuNoOld[ curVoice->ID], intDriver->NoteOld[ curVoice->ID], intDriver->VelocityOld[ curVoice->ID], intDriver);
  475.         intDriver->NoteOld[ curVoice->ID] = -1;
  476.     }
  477. }
  478. }
  479.  
  480. #if defined(powerc) || defined (__powerc)
  481. void ClearDouble( register double long *a, register long xx)
  482. {
  483.     while( xx-- > 0 ) *a++ = 0;
  484. }
  485.  
  486. #else
  487. void ClearDouble( register long *a, register long xx)
  488. {
  489.     xx *=2;
  490.     while( xx-- > 0 ) *a++ = 0;
  491. }
  492. #endif
  493.  
  494. void ComputeReverb8(  Byte *orgPtr,   Byte *destPtr,  long xx, long strength)
  495. {
  496.     long    temp1;
  497.     
  498.     while( xx-- > 0)
  499.     {
  500.         temp1 = (*destPtr) + ((strength * (*orgPtr++ - 0x80)) / 100L);        // - 0x80L
  501.         
  502.         if( temp1 > 0xFF) temp1 = 0xFF;    // overflow ?
  503.         else if( temp1 < 0 ) temp1 = 0;
  504.         
  505.         *(destPtr)++ = temp1;
  506.     }
  507. }
  508.  
  509. void ComputeReverb16( short *orgPtr, short *destPtr, long xx, long strength)
  510. {
  511.     long    temp1;
  512.     long    valP = 0x7FFFL, valN = -0x7FFFL;
  513.     
  514.     while( xx-- > 0)
  515.     {
  516.         temp1 = *destPtr + ((strength * (long) *orgPtr++) / 100L);
  517.         
  518.         if( temp1 > valP) temp1 = valP;    // overflow ?
  519.         else if( temp1 < valN ) temp1 = valN;
  520.         
  521.         *destPtr++ = temp1;
  522.     }
  523. }
  524.  
  525. void NoteAnalyse( MADDriverRec *intDriver)
  526. {
  527. long                    InterruptBufferSize, i, ASCBUFFERCopy;
  528. Ptr                        DataPtrCopy;
  529. long                    tVSYNC;
  530. Boolean                NoteReading;
  531. long                    *DASCopy;
  532. short                    *DASCopy8;
  533.  
  534.     if( intDriver->curMusic != 0L)
  535.     {
  536.         if( intDriver->curMusic->musicUnderModification)
  537.         {    // SILENCE
  538.             long Tracks;
  539.             
  540.             if( intDriver->curMusic->header->MAD != 'MADH') DebugStr("\pError in MADH");
  541.             
  542.             switch( intDriver->DriverSettings.outPutMode)
  543.             {
  544.                 case MonoOutPut:                    Tracks  = 1;    break;
  545.                 case PolyPhonic:                    Tracks    = intDriver->DriverSettings.numChn;    break;
  546.                 case MultiFiles:                    Tracks    = intDriver->DriverSettings.numChn;    break;
  547.                 default:                                    Tracks  = 2;    break;
  548.             }
  549.             
  550.             Tracks = 1;
  551.             
  552.             switch( intDriver->DriverSettings.outPutBits)
  553.             {
  554.                 case 8:
  555.                     for( i = 0; i < intDriver->ASCBUFFER*Tracks; i++) intDriver->IntDataPtr[ i] = 0x80;
  556.                 break;
  557.                 
  558.                 case 16:
  559.                     DASCopy8 = (short*) intDriver->IntDataPtr;
  560.                     for( i = 0; i < intDriver->ASCBUFFER*Tracks*2L; i++) DASCopy8[ i] = 0;
  561.                 break;
  562.             }
  563.             return;
  564.         }
  565.     }
  566.     
  567.     DataPtrCopy                    = intDriver->IntDataPtr;
  568.     DASCopy                            = intDriver->DASCBuffer;
  569.     DASCopy8                        = intDriver->DASCBuffer8;
  570.     ASCBUFFERCopy                = intDriver->ASCBUFFER;
  571.     InterruptBufferSize = intDriver->ASCBUFFER;
  572.     
  573.     while( InterruptBufferSize > 0)
  574.     {
  575.         /********************/
  576.         /* Sound Generating */
  577.         /********************/
  578.         
  579.         intDriver->ASCBUFFER = intDriver->BytesToGenerate - intDriver->BufCounter;
  580.         
  581.         if( intDriver->ASCBUFFER < 0) intDriver->ASCBUFFER = 0;
  582.         if( intDriver->ASCBUFFER > InterruptBufferSize) { intDriver->ASCBUFFER = InterruptBufferSize;    NoteReading = false;}
  583.         else NoteReading = true;
  584.         
  585.         if( intDriver->ASCBUFFER > 0)
  586.         {
  587.             GenerateSound( intDriver);
  588.             intDriver->BufCounter    += intDriver->ASCBUFFER;
  589.             InterruptBufferSize        -= intDriver->ASCBUFFER;
  590.         }
  591.         
  592.         /**************************/
  593.         /* Note & Effect Analyser */
  594.         /**************************/
  595.         
  596.         if( !NoteReading) InterruptBufferSize = -1;
  597.         else
  598.         {
  599.             NoteReading = false;
  600.             
  601.             /*********/
  602.             // GEffect : extrasmallpositionning
  603.             
  604.             if( intDriver->curMusic != 0L && intDriver->Reading)
  605.             {
  606.                 for( i = 0; i < intDriver->curMusic->header->numChn; i++)
  607.                 {
  608.                     if( intDriver->chan[ i].GEffect)        
  609.                     {
  610.                         ReadNote( &intDriver->chan[ i], GetMADCommand( intDriver->chan[ i].GReader, i, intDriver->curMusic->partition[ intDriver->chan[ i].GPat]), intDriver);
  611.                     }
  612.                 }
  613.             }
  614.             
  615.             /*********/
  616.             
  617.         //    intDriver->extrasmallcounter--;
  618.         //    if( intDriver->extrasmallcounter <= 0)
  619.             {
  620.             //    intDriver->extrasmallcounter = EXTRASMALLCOUNTER;
  621.                 
  622.                 intDriver->smallcounter++;
  623.                 if( intDriver->smallcounter >= intDriver->speed)
  624.                 {
  625.                     intDriver->smallcounter = 0;
  626.                     
  627.                     if( intDriver->curMusic != 0L)
  628.                     {
  629.                         for( i = 0; i < intDriver->curMusic->header->numChn; i++)
  630.                         {
  631.                             if( intDriver->Reading && intDriver->TrackLineReading[ i])
  632.                             {
  633.                                 ReadNote( &intDriver->chan[ i], GetMADCommand( intDriver->PartitionReader, i, intDriver->curMusic->partition[ intDriver->Pat]), intDriver);
  634.                             }
  635.                             
  636.                             ProcessEnvelope( &intDriver->chan[ i], intDriver);
  637.                             ProcessFadeOut( &intDriver->chan[ i], intDriver);
  638.                         }
  639.                         
  640.                         if( intDriver->Reading)
  641.                         {
  642.                             for( i = 0; i < MAXTRACK; i++) intDriver->TrackLineReading[ i] = true;
  643.                             
  644.                             intDriver->PartitionReader++;
  645.                             if( intDriver->PartitionReader >= intDriver->curMusic->partition[ intDriver->Pat]->header.size)
  646.                             {
  647.                                 intDriver->PartitionReader = 0;
  648.                                 intDriver->endPattern = true;
  649.                                 
  650.                                 if( intDriver->JumpToNextPattern)
  651.                                 {
  652.                                     intDriver->PL++;
  653.                                     intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  654.                                     
  655.                                     if( intDriver->speed == 1 && intDriver->PL >= intDriver->curMusic->header->numPointers)
  656.                                     {
  657.                                         intDriver->PL = 0;
  658.                                         intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  659.                                         
  660.                                         MADCleanDriver( intDriver);
  661.                                         if( !intDriver->DriverSettings.repeatMusic) intDriver->Reading = false;
  662.                                         
  663.                                         intDriver->musicEnd = true;
  664.                                     }
  665.                                 }
  666.                             }
  667.                         }
  668.                     }
  669.                 }
  670.                 else
  671.                 {
  672.                     if( intDriver->curMusic != 0L)
  673.                     {
  674.                         for( i = 0 ; i < intDriver->DriverSettings.numChn; i++)
  675.                         {
  676.                             //    if( intDriver->Reading) 
  677.                                 {
  678.                                     DoVolCmd( &intDriver->chan[ i], intDriver->smallcounter, intDriver);
  679.                                     DoEffect( &intDriver->chan[ i], intDriver->smallcounter, intDriver);
  680.                                 }
  681.                                 ProcessEnvelope( &intDriver->chan[ i], intDriver);
  682.                                 ProcessFadeOut( &intDriver->chan[ i], intDriver);
  683.                         }
  684.                         
  685.                         if( intDriver->Reading)
  686.                         {
  687.                             if( intDriver->smallcounter == intDriver->speed - 1)
  688.                             {
  689.                                 if( intDriver->PL >= intDriver->curMusic->header->numPointers)
  690.                                 {
  691.                                     intDriver->PL = 0;
  692.                                     intDriver->Pat = intDriver->curMusic->header->oPointers[ intDriver->PL];
  693.                                     
  694.                                     MADCleanDriver( intDriver);
  695.                                     if( !intDriver->DriverSettings.repeatMusic) intDriver->Reading = false;
  696.                                     
  697.                                     intDriver->musicEnd = true;
  698.                                 }
  699.                             }
  700.                         }
  701.                     }
  702.                 }
  703.             }
  704.             tVSYNC         = intDriver->VSYNC;
  705.             tVSYNC         /= intDriver->finespeed;
  706.             
  707.             tVSYNC         *= 80L;
  708.             tVSYNC         /= intDriver->VExt;
  709.             
  710.             intDriver->BytesToGenerate += tVSYNC;
  711.         }
  712.     }
  713.     
  714.     intDriver->ASCBUFFER    = ASCBUFFERCopy;
  715.     intDriver->IntDataPtr    = DataPtrCopy;
  716.     intDriver->DASCBuffer    = DASCopy;
  717.     intDriver->DASCBuffer8    = DASCopy8;
  718.     
  719.     if( intDriver->DriverSettings.MicroDelay == true && intDriver->DriverSettings.outPutMode == DeluxeStereoOutPut)
  720.     {
  721.         switch( intDriver->DriverSettings.outPutBits)
  722.         {
  723.             case 16:
  724.                 BlockMoveData( intDriver->DASCBuffer + intDriver->ASCBUFFER*2, intDriver->DASCBuffer, intDriver->MDelay*8L);
  725.                 
  726.                 #if defined (powerc)
  727.                 ClearDouble( (long double*) (intDriver->DASCBuffer + intDriver->MDelay*2L), intDriver->ASCBUFFER);
  728.                 #else
  729.                 ClearDouble( (long*) (intDriver->DASCBuffer + intDriver->MDelay*2L), intDriver->ASCBUFFER);
  730.                 #endif
  731.             break;
  732.             
  733.             case 8:
  734.                 if( intDriver->MDelay % 2 != 0)
  735.                 {
  736.                     BlockMoveData( intDriver->DASCBuffer8 + intDriver->ASCBUFFER*2, intDriver->DASCBuffer8, 1 + intDriver->MDelay*4L);
  737.                     
  738.                     #if defined (powerc)
  739.                     ClearDouble( (long double*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), 1 + intDriver->ASCBUFFER/2);
  740.                     #else
  741.                     ClearDouble( (long*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), 1 + intDriver->ASCBUFFER/2);
  742.                     #endif
  743.                 }
  744.                 else
  745.                 {
  746.                     BlockMoveData( intDriver->DASCBuffer8 + intDriver->ASCBUFFER*2, intDriver->DASCBuffer8, intDriver->MDelay*4L);
  747.                 
  748.                     #if defined (powerc)
  749.                     ClearDouble( (long double*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), intDriver->ASCBUFFER/2);
  750.                     #else
  751.                     ClearDouble( (long*) (intDriver->DASCBuffer8 + intDriver->MDelay*2L), intDriver->ASCBUFFER/2);
  752.                     #endif
  753.                 }
  754.             break;
  755.         }
  756.     }
  757.     
  758.     if( intDriver->DriverSettings.antiAliasing) ApplyFilters( intDriver);
  759.     if( intDriver->DriverSettings.surround) ApplySurround( intDriver);
  760.     
  761.     if( intDriver->DriverSettings.Reverb && intDriver->ASCBUFFER < intDriver->RDelay)
  762.     {
  763.         if( intDriver->DriverSettings.outPutMode == StereoOutPut ||
  764.             intDriver->DriverSettings.outPutMode == DeluxeStereoOutPut)
  765.         {
  766.             switch( intDriver->DriverSettings.outPutBits)
  767.             {
  768.                 case 8:
  769.                     ComputeReverb8( (Byte*) intDriver->ReverbPtr, (Byte*) intDriver->IntDataPtr, intDriver->ASCBUFFER*2L, intDriver->DriverSettings.ReverbStrength);
  770.                     BlockMoveData( intDriver->ReverbPtr + intDriver->ASCBUFFER*2L, intDriver->ReverbPtr, intDriver->RDelay*2L - intDriver->ASCBUFFER*2L);
  771.                     BlockMoveData( intDriver->IntDataPtr, intDriver->ReverbPtr + intDriver->RDelay*2L - intDriver->ASCBUFFER*2L, intDriver->ASCBUFFER*2L);
  772.                 break;
  773.                 
  774.                 case 16:
  775.                     ComputeReverb16( (short*) intDriver->ReverbPtr, (short*) intDriver->IntDataPtr, intDriver->ASCBUFFER*2L, intDriver->DriverSettings.ReverbStrength);
  776.                     BlockMoveData( intDriver->ReverbPtr + intDriver->ASCBUFFER*4, intDriver->ReverbPtr, (intDriver->RDelay - intDriver->ASCBUFFER)*4);
  777.                     BlockMoveData( intDriver->IntDataPtr, intDriver->ReverbPtr + intDriver->RDelay*4 - intDriver->ASCBUFFER*4, intDriver->ASCBUFFER*4);
  778.                 break;
  779.             }
  780.         }
  781.     }
  782. }
  783.  
  784. void Filter8Bit( register Byte *myPtr, MADDriverRec *intDriver)
  785. {
  786.     long    i;
  787.  
  788.     i = intDriver->ASCBUFFER-1;
  789.     while( i-- > 0)
  790.     {
  791.         *myPtr -= ( *myPtr - *(myPtr + 1)) >> 1;
  792.         myPtr++;
  793.     }
  794. }
  795.  
  796. void Filter8BitX( register Byte *myPtr, MADDriverRec *intDriver)
  797. {
  798.     long    i;
  799.  
  800.     i = intDriver->ASCBUFFER-1;
  801.     while( i-- > 0)
  802.     {
  803.         *myPtr -= ( *myPtr - *(myPtr + 2)) >> 1;
  804.         myPtr += 2;
  805.     }
  806. }
  807.  
  808. void Filter16BitX( register short *myPtr, MADDriverRec *intDriver)
  809. {
  810.     long    i;
  811.  
  812.     i = intDriver->ASCBUFFER-1;
  813.     while( i-- > 0)
  814.     {
  815.         *myPtr -= ( *myPtr - *(myPtr + 2)) >> 1;
  816.         myPtr += 2;
  817.     }
  818.     
  819. /*    i = intDriver->ASCBUFFER-2;
  820.     myPtr += 2;
  821.     while( i-- > 0)
  822.     {
  823.         *myPtr -= ((*myPtr - *(myPtr + 2)) + (*myPtr - *(myPtr - 2))) >> 1;
  824.         myPtr += 2;
  825.     }    */
  826. }
  827.  
  828. void ApplyFilters( MADDriverRec *intDriver)
  829. {
  830.     switch( intDriver->DriverSettings.outPutBits)
  831.     {
  832.         case 8:
  833.             switch( intDriver->DriverSettings.outPutMode)
  834.             {
  835.                 case MonoOutPut:
  836.                     Filter8Bit( (Byte*) intDriver->IntDataPtr, intDriver);
  837.                 break;
  838.                 
  839.                 case StereoOutPut:
  840.                     Filter8BitX( (Byte*) intDriver->IntDataPtr, intDriver);
  841.                     Filter8BitX( (Byte*) intDriver->IntDataPtr + 1, intDriver);
  842.                 break;
  843.                 
  844.                 case DeluxeStereoOutPut:
  845.                     Filter8BitX( (Byte*) intDriver->IntDataPtr, intDriver);
  846.                     Filter8BitX( (Byte*) intDriver->IntDataPtr + 1, intDriver);
  847.                 break;
  848.             }
  849.         break;
  850.         
  851.         case 16:
  852.             switch( intDriver->DriverSettings.outPutMode)
  853.             {
  854.                 case MonoOutPut:
  855.                 break;
  856.                 
  857.                 case StereoOutPut:
  858.                 case DeluxeStereoOutPut:
  859.                 
  860.             /*    {
  861.                 short    i;
  862.                     
  863.                     for( i = 0; i < 10; i++)
  864.                     {*/
  865.                         Filter16BitX( ( short*) intDriver->IntDataPtr, intDriver);
  866.                         Filter16BitX( ( short*) (intDriver->IntDataPtr) + 1, intDriver);
  867.                 /*    }
  868.                 }*/
  869.                 break;
  870.             }
  871.         break;
  872.     }
  873. }
  874.  
  875. void ApplySurround( MADDriverRec *intDriver)
  876. {
  877.     switch( intDriver->DriverSettings.outPutBits)
  878.     {
  879.         case 8:
  880.             switch( intDriver->DriverSettings.outPutMode)
  881.             {
  882.                 case DeluxeStereoOutPut:
  883.                 {
  884.                 long    i = intDriver->ASCBUFFER;
  885.                 char    *data = (char*) intDriver->IntDataPtr;
  886.                     
  887.                     while( i-- > 0)
  888.                     {
  889.                         *data = -1-*data;
  890.                         data += 2;
  891.                     }
  892.                 }
  893.                 break;
  894.             }
  895.         break;
  896.         
  897.         case 16:
  898.             switch( intDriver->DriverSettings.outPutMode)
  899.             {
  900.                 case DeluxeStereoOutPut:
  901.                 {
  902.                 long        i = intDriver->ASCBUFFER;
  903.                 short        *data = (short*) intDriver->IntDataPtr;
  904.                     
  905.                     while( i-- > 0)
  906.                     {
  907.                         *data = -1-*data;
  908.                         data += 2;
  909.                     }
  910.                 }
  911.                 break;
  912.             }
  913.         break;
  914.     }
  915. }
  916.  
  917. void GenerateSound( MADDriverRec *intDriver)
  918. {
  919.     long volExtCopy[ MAXTRACK], i;
  920.     
  921.     for( i = 0; i < MAXTRACK; i++)
  922.     {
  923.         volExtCopy[ i] = intDriver->VolExt[ i];
  924.         
  925.         intDriver->VolExt[ i] = (intDriver->VolExt[ i] * intDriver->VolGlobal) / 64L;
  926.     }
  927.  
  928.     switch( intDriver->DriverSettings.outPutBits)
  929.     {
  930.         case 8:
  931.             switch( intDriver->DriverSettings.outPutMode)
  932.             {
  933.                 case MonoOutPut:
  934.                     Play8Mono( intDriver);
  935.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER;
  936.                 break;
  937.                 
  938.                 case StereoOutPut:
  939.                     Play8Stereo( intDriver);
  940.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  941.                 break;
  942.                 
  943.                 case DeluxeStereoOutPut:
  944.                     if( intDriver->DriverSettings.MicroDelay) Play8StereoDelay( intDriver);
  945.                     else Play8StereoDeluxe( intDriver);
  946.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  947.                     intDriver->DASCBuffer8    += intDriver->ASCBUFFER*2L;
  948.                 break;
  949.                 
  950.                 case PolyPhonic:
  951.                 case MultiFiles:
  952.                     Play8PolyPhonic( intDriver);
  953.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER * intDriver->DriverSettings.numChn;
  954.                 break;
  955.             }
  956.         break;
  957.         
  958.         case 16:
  959.             switch( intDriver->DriverSettings.outPutMode)
  960.             {
  961.                 case MonoOutPut:
  962.                     Play16Mono( intDriver);
  963.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*2L;
  964.                 break;
  965.                 
  966.                 case StereoOutPut:
  967.                     Play16Stereo( intDriver);
  968.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*4L;
  969.                 break;
  970.                 
  971.                 case DeluxeStereoOutPut:
  972.                     if( intDriver->DriverSettings.MicroDelay) Play16StereoDelay( intDriver);
  973.                     else Play16StereoDeluxe( intDriver);
  974.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER*4L;
  975.                     intDriver->DASCBuffer    += intDriver->ASCBUFFER*2L;
  976.                 break;
  977.                 
  978.                 case PolyPhonic:
  979.                 case MultiFiles:
  980.                     Play16PolyPhonic( intDriver);
  981.                     intDriver->IntDataPtr    += intDriver->ASCBUFFER * 2L * intDriver->DriverSettings.numChn;
  982.                 break;
  983.             }
  984.         break;
  985.     }
  986.     
  987.     for( i = 0; i < MAXTRACK; i++)
  988.     {
  989.         intDriver->VolExt[ i] = volExtCopy[ i];
  990.     }
  991. }
  992.  
  993. Boolean DirectSave( Ptr myPtr, MADDriverSettings *driverType, MADDriverRec *intDriver)
  994. {
  995. Ptr                                    ptrCopy;
  996. MADDriverSettings        driverCopy;
  997.  
  998.     if( intDriver == 0L) return false;    //intDriver = MADGetMADDriverPtr();
  999.     if( !intDriver->Reading) return false;
  1000.     
  1001.     /*** Copy values ***/
  1002.     ptrCopy         = intDriver->IntDataPtr;
  1003.     if( driverType != 0L) driverCopy    = intDriver->DriverSettings;
  1004.     
  1005.     /*** Install New Values ***/
  1006.     
  1007.     intDriver->IntDataPtr         = myPtr;
  1008.     if( driverType != 0L) intDriver->DriverSettings    = *driverType;
  1009.  
  1010.     /***/            /***/
  1011.     /***/            /***/
  1012.     /***/            /***/
  1013.     
  1014.     NoteAnalyse( intDriver);
  1015.     
  1016.     /***/            /***/
  1017.     /***/            /***/
  1018.     /***/            /***/
  1019.     
  1020.     /*** Restore values ***/
  1021.     
  1022.     intDriver->IntDataPtr         = ptrCopy;
  1023.     if( driverType != 0L) intDriver->DriverSettings    = driverCopy;
  1024.     
  1025.     if( intDriver->musicEnd == true) return false;
  1026.     
  1027.     if( intDriver->curMusic != 0L)
  1028.     {
  1029.         if( intDriver->PL >= intDriver->curMusic->header->numPointers) return false;
  1030.     }
  1031.     
  1032.     return true;
  1033. }
  1034.  
  1035. pascal void DMAPlay ( void)
  1036. {
  1037. /*unsigned    long                deferredArg;
  1038.             long                        *destPtr;
  1039.             Boolean                    DMAPlayNow;
  1040.             short                        *tempIntG = 0L;
  1041.             Ptr                            myPtr;
  1042.             MADDriverRec        *intDriver = MADGetMADDriverPtr();
  1043.             
  1044.     DMAPlayNow = false;
  1045.  
  1046.     if (SND_OUT_IF0)                            // buffer 0 just finished
  1047.     {
  1048.         deferredArg = kBuf0Offset;                // set offset for copy
  1049.         CLEAR_SND_OUT_IF0;                        // clear offending bit
  1050.         destPtr = ( long*) ((long) DMABufferBase + (long) deferredArg);
  1051.  
  1052.         DMAPlayNow = true;
  1053.     }
  1054.  
  1055.     if (SND_OUT_IF1)                            // buffer 1 just finished
  1056.     {
  1057.         deferredArg = kBuf1Offset;                // set offset for copy
  1058.         CLEAR_SND_OUT_IF1;                        // clear offending bit
  1059.         destPtr = ( long*) ((long) DMABufferBase + (long) deferredArg);
  1060.  
  1061.         DMAPlayNow = true;
  1062.     }
  1063.     
  1064.     if (SND_OUT_UNDERRUN)                        // whoops - we underran! clear it, re-enable DMA, & vamoose
  1065.     {
  1066.         CLEAR_UNDERRUN_INT;                        // only one kind of output error
  1067.         SND_OUT_DMA_ENABLE;                        // re-enable sound out (underrun will have stopped it)
  1068.         return;                                    // return without setting up the DeferUserFn
  1069.     }
  1070.  
  1071.     if( DMAPlayNow)
  1072.     {
  1073.         myPtr = intDriver->IntDataPtr;
  1074.         intDriver->IntDataPtr = (Ptr) destPtr;
  1075.         
  1076.         DISABLE_BUF_AND_UNDERRUN_INTS;
  1077.         
  1078.         NoteAnalyse( intDriver);
  1079.  
  1080.         ENABLE_BUF_AND_UNDERRUN_INTS;
  1081.         
  1082.         intDriver->OscilloWavePtr = intDriver->IntDataPtr;
  1083.         intDriver->IntDataPtr = myPtr;
  1084.     }*/
  1085. }
  1086.  
  1087.  
  1088. #ifdef _MAC_H
  1089.  
  1090. Ptr GetMyDoubleBackProc()
  1091. {
  1092.     return (Ptr) MyDoubleBackProc;
  1093. }
  1094.  
  1095. pascal void MyDoubleBackProc(SndChannelPtr chan, SndDoubleBufferPtr doubleBuffer)
  1096. {
  1097.     Ptr                            myPtr;            
  1098.     MADDriverRec        *intDriver;
  1099.     
  1100.     intDriver = (MADDriverRec*) doubleBuffer->dbUserInfo[ 0];
  1101.     
  1102.     /********************/
  1103.     /**   Read Notes   **/
  1104.     /********************/
  1105.     
  1106.     myPtr = intDriver->IntDataPtr;
  1107.     intDriver->IntDataPtr = (char*) doubleBuffer->dbSoundData;
  1108.     
  1109.     NoteAnalyse( intDriver);
  1110.     
  1111.     intDriver->IntDataPtr        = myPtr;
  1112.     intDriver->OscilloWavePtr    = (char*) doubleBuffer->dbSoundData;
  1113.     
  1114.     doubleBuffer->dbNumFrames    = intDriver->ASCBUFFER;
  1115.     doubleBuffer->dbFlags        |= dbBufferReady;
  1116. }
  1117.  
  1118. #if defined(powerc) || defined (__powerc)
  1119. pascal void MODPlay (VBLTaskPtr theVBLTask)
  1120. {
  1121. //    MADDriverRec *intDriver = MADGetMADDriverPtr();
  1122.  
  1123.     DebugStr("\pNOT WORKING");
  1124. /*
  1125.     theVBLTask->vblCount = 1;
  1126.  
  1127.     if( intDriver->DriverSettings.driverMode != MIDISoundDriver) VIAOn2();
  1128.     
  1129.     NoteAnalyse( intDriver);
  1130.     
  1131.     if( intDriver->DriverSettings.driverMode != MIDISoundDriver)
  1132.     {
  1133.         switch( intDriver->DriverSettings.outPutMode)
  1134.         {
  1135.             case MonoOutPut:
  1136.                 BufferCopyM( intDriver);
  1137.             break;
  1138.             
  1139.             default:
  1140.                 BufferCopyS( intDriver);
  1141.             break;
  1142.         }
  1143.     }*/
  1144. }
  1145. #else
  1146. pascal long GetVBLRec( void) = 0x2E88;
  1147.  
  1148. void MODPlay()    //ASCMono et ASCStereo
  1149. {
  1150.     inVBLRec                *recPtr;
  1151.     MADDriverRec        *intDriver;
  1152.     
  1153.     recPtr = (inVBLRec*) GetVBLRec();
  1154.     
  1155.     intDriver = (MADDriverRec*) recPtr->VBLA5;
  1156.     recPtr->VBL.vblCount = 1;
  1157.     
  1158.     if( intDriver->DriverSettings.driverMode != MIDISoundDriver) VIAOn2();
  1159.     
  1160.     NoteAnalyse( intDriver);
  1161.     
  1162.     if( intDriver->DriverSettings.driverMode != MIDISoundDriver)
  1163.     {
  1164.         switch( intDriver->DriverSettings.outPutMode)
  1165.         {
  1166.             case MonoOutPut:
  1167.                 BufferCopyM( intDriver);
  1168.             break;
  1169.             
  1170.             default:
  1171.                 BufferCopyS( intDriver);
  1172.             break;
  1173.         }
  1174.     }
  1175. }
  1176. #endif
  1177. #endif
  1178.  
  1179. void BufferCopyM( MADDriverRec *intDriver)
  1180. {
  1181.     Ptr    srcPtr = intDriver->IntDataPtr, destPtr = *((Ptr*) ASCBase);
  1182.     
  1183.     BlockMoveData( srcPtr, destPtr, 370L);
  1184. }
  1185.  
  1186. void BufferCopyS( MADDriverRec *intDriver)
  1187. {
  1188.     register    Ptr        srcPtr = intDriver->IntDataPtr, leftPtr = *((Ptr*) ASCBase), rightPtr = *((Ptr*) ASCBase) + 0x400L;
  1189.     register    short    x = 370;    
  1190.  
  1191.     while( x-- > 0)
  1192.     {
  1193.         *leftPtr++        = *srcPtr++;
  1194.         *rightPtr++        = *srcPtr++;
  1195.     }
  1196. }
  1197.  
  1198. #ifdef _MAC_H
  1199.  
  1200. void NoteOff(short oldIns, short oldN, short oldV, MADDriverRec *intDriver)
  1201. {
  1202.     OMSMIDIPacket pack;
  1203.     
  1204.     if( intDriver->gOutNodeRefNum == -1) return;
  1205.     
  1206.     /*** Note - OFF ***/
  1207.  
  1208.     pack.flags    = 0;    //midiMsgType + midiTimeStampCurrent + midiNoCont;
  1209.     pack.len    = 3;
  1210.  
  1211.     pack.data[ 0] = 0x80 + oldIns;
  1212.     pack.data[ 1] = oldN + 12;
  1213.     
  1214.     if( oldV < 64) pack.data[ 2] = 63 + oldV;    
  1215.     else pack.data[ 2] = 127;
  1216.     
  1217.     #if defined(__MWERKS__)
  1218.     OMSWritePacket2( &pack, intDriver->gOutNodeRefNum, intDriver->MIDIPortRefNum);
  1219.     #endif
  1220. }
  1221.  
  1222. void AllNoteOff( MADDriverRec *intDriver)
  1223. {
  1224.     short         i;
  1225.     
  1226.     if( intDriver->gOutNodeRefNum == -1) return;
  1227.     
  1228.     for( i = 0; i < MAXTRACK; i++)
  1229.     {
  1230.         if( intDriver->NoteOld[ i] != -1)
  1231.         {
  1232.             NoteOff( intDriver->InstuNoOld[ i], intDriver->NoteOld[ i], intDriver->VelocityOld[ i], intDriver);
  1233.             intDriver->NoteOld[ i] = -1;
  1234.         }
  1235.     }
  1236. }
  1237.  
  1238. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver)
  1239. {
  1240.     OMSMIDIPacket pack;
  1241.     
  1242.     if( intDriver->gOutNodeRefNum == -1) return;
  1243.     
  1244.     /*** Note - ON ***/
  1245.     
  1246.     pack.flags    = 0;    //midiMsgType + midiTimeStampCurrent + midiNoCont;
  1247.     pack.len    = 3;
  1248.  
  1249.     pack.data[ 0] = 0x90 + channel;
  1250.     
  1251.     pack.data[ 1] = curN + 12;
  1252.     if( curVoice->vol < 64) pack.data[ 2] = 63 + curVoice->vol;    
  1253.     else pack.data[ 2] = 127;
  1254.     
  1255.     #if defined(__MWERKS__)
  1256.     OMSWritePacket2( &pack, intDriver->gOutNodeRefNum, intDriver->MIDIPortRefNum);
  1257.     #endif
  1258. }
  1259. #else
  1260. void SampleMIDI( Channel *curVoice, short channel, short curN, MADDriverRec *intDriver){};
  1261. void AllNoteOff( MADDriverRec *intDriver){};
  1262. void NoteOff(short oldIns, short oldN, short oldV, MADDriverRec *intDriver){};
  1263. #endif
  1264.